package logger

import (
	"fmt"
	"strings"
	"time"

	"github.com/fatih/color"
)

// Logger 日志显示模块
type Logger struct {
	startTime time.Time
}

// NewLogger 创建新的日志显示模块
func NewLogger() *Logger {
	return &Logger{
		startTime: time.Now(),
	}
}

// Info 显示信息日志
func (l *Logger) Info(format string, args ...interface{}) {
	blue := color.New(color.FgBlue).SprintFunc()
	timestamp := time.Since(l.startTime).Round(time.Millisecond)
	fmt.Printf("[%s] %s\n", blue(timestamp), fmt.Sprintf(format, args...))
}

// Success 显示成功日志
func (l *Logger) Success(format string, args ...interface{}) {
	green := color.New(color.FgGreen).SprintFunc()
	timestamp := time.Since(l.startTime).Round(time.Millisecond)
	fmt.Printf("[%s] %s\n", green(timestamp), fmt.Sprintf(format, args...))
}

// Warning 显示警告日志
func (l *Logger) Warning(format string, args ...interface{}) {
	yellow := color.New(color.FgYellow).SprintFunc()
	timestamp := time.Since(l.startTime).Round(time.Millisecond)
	fmt.Printf("[%s] %s\n", yellow(timestamp), fmt.Sprintf(format, args...))
}

// Error 显示错误日志
func (l *Logger) Error(format string, args ...interface{}) {
	red := color.New(color.FgRed).SprintFunc()
	timestamp := time.Since(l.startTime).Round(time.Millisecond)
	fmt.Printf("[%s] %s\n", red(timestamp), fmt.Sprintf(format, args...))
}

// Progress 显示进度信息
func (l *Logger) Progress(current, total int, message string) {
	cyan := color.New(color.FgCyan).SprintFunc()
	percentage := float64(current) / float64(total) * 100
	fmt.Printf("\r[%s] %s: %.1f%% (%d/%d)",
		cyan(time.Since(l.startTime).Round(time.Millisecond)),
		message,
		percentage,
		current,
		total)
	if current == total {
		fmt.Println()
	}
}

// Table 显示表格数据
func (l *Logger) Table(
	headers []string,
	rows [][]string,
) {
	cyan := color.New(color.FgCyan).SprintFunc()
	yellow := color.New(color.FgYellow).SprintFunc()

	// 计算每列的最大宽度（考虑中文字符占用两个字符宽度）
	colWidths := make([]int, len(headers))
	for i, header := range headers {
		colWidths[i] = getRealWidth(header)
	}
	for _, row := range rows {
		for i, cell := range row {
			if i < len(colWidths) && getRealWidth(cell) > colWidths[i] {
				colWidths[i] = getRealWidth(cell)
			}
		}
	}

	// 确保每列至少有最小宽度，特别是对短内容的列（如"是/否"列）
	minColWidth := 4 // 最小列宽
	for i := range colWidths {
		if colWidths[i] < minColWidth {
			colWidths[i] = minColWidth
		}
	}

	// 打印表头
	fmt.Print(cyan("┌"))
	for i, width := range colWidths {
		fmt.Print(cyan(strings.Repeat("─", width+2)))
		if i < len(colWidths)-1 {
			fmt.Print(cyan("┬"))
		}
	}
	fmt.Println(cyan("┐"))

	// 打印表头内容
	fmt.Print(cyan("│"))
	for i, header := range headers {
		padding := colWidths[i] - getRealWidth(header)
		fmt.Print(" " + yellow(header) + strings.Repeat(" ", padding) + " " + cyan("│"))
	}
	fmt.Println()

	// 打印分隔线
	fmt.Print(cyan("├"))
	for i, width := range colWidths {
		fmt.Print(cyan(strings.Repeat("─", width+2)))
		if i < len(colWidths)-1 {
			fmt.Print(cyan("┼"))
		}
	}
	fmt.Println(cyan("┤"))

	// 打印数据行
	for _, row := range rows {
		fmt.Print(cyan("│"))
		for i := 0; i < len(colWidths); i++ {
			if i < len(row) {
				cell := row[i]
				padding := colWidths[i] - getRealWidth(cell)
				fmt.Print(" " + cell + strings.Repeat(" ", padding) + " " + cyan("│"))
			} else {
				// 处理行中缺少列的情况
				fmt.Print(" " + strings.Repeat(" ", colWidths[i]) + " " + cyan("│"))
			}
		}
		fmt.Println()
	}

	// 打印底部边框
	fmt.Print(cyan("└"))
	for i, width := range colWidths {
		fmt.Print(cyan(strings.Repeat("─", width+2)))
		if i < len(colWidths)-1 {
			fmt.Print(cyan("┴"))
		}
	}
	fmt.Println(cyan("┘"))
}

// getRealWidth 获取字符串的实际显示宽度（中文字符计为2）
func getRealWidth(s string) int {
	width := 0
	for _, r := range s {
		if isWideChar(r) {
			width += 2
		} else {
			width += 1
		}
	}
	return width
}

// isWideChar 判断字符是否为宽字符（占据2个显示宽度）
func isWideChar(r rune) bool {
	// CJK 统一表意文字 - 中日韩文字
	if r >= 0x4E00 && r <= 0x9FFF {
		return true
	}

	// CJK 扩展表意文字
	if r >= 0x3400 && r <= 0x4DBF {
		return true
	}

	// CJK 兼容表意文字
	if r >= 0xF900 && r <= 0xFAFF {
		return true
	}

	// CJK 兼容表意文字补充
	if r >= 0x2F800 && r <= 0x2FA1F {
		return true
	}

	// 中日韩标点符号
	if r >= 0x3000 && r <= 0x303F {
		return true
	}

	// 全角ASCII、全角标点
	if r >= 0xFF01 && r <= 0xFF60 {
		return true
	}

	// 半宽和全宽表格
	if r >= 0xFF61 && r <= 0xFFDC {
		return true
	}

	// 全角符号
	if r >= 0xFFE0 && r <= 0xFFE6 {
		return true
	}

	return false
}

// Separator 显示分隔线
func (l *Logger) Separator() {
	cyan := color.New(color.FgCyan).SprintFunc()
	fmt.Println(cyan("──────────────────────────────────────────────────────────"))
}

// Banner 显示横幅
func (l *Logger) Banner() {
	red := color.New(color.FgRed).SprintFunc()
	yellow := color.New(color.FgYellow).SprintFunc()
	cyan := color.New(color.FgCyan).SprintFunc()

	bannerWidth := 56 // 横幅宽度
	titleText := "红方攻击系统 v1.0.0"

	// 计算标题居中所需的左右填充
	titleWidth := getRealWidth(titleText)
	leftPadding := (bannerWidth - titleWidth) / 2
	rightPadding := bannerWidth - titleWidth - leftPadding

	leftPaddingStr := strings.Repeat(" ", leftPadding)
	rightPaddingStr := strings.Repeat(" ", rightPadding)

	// 顶部边框
	topBorder := strings.Repeat("═", bannerWidth)
	fmt.Println()
	fmt.Println(red("╔" + topBorder + "╗"))

	// 标题行
	fmt.Println(red("║") + leftPaddingStr + yellow(titleText) + rightPaddingStr + red("║"))

	// 分隔线
	fmt.Println(red("╠" + topBorder + "╣"))

	// 功能项及其填充
	features := []string{
		"信息收集 - 目标侦察与信息收集",
		"漏洞利用 - 漏洞扫描与利用",
		"持久化控制 - 后门植入与权限维持",
		"防御绕过 - WAF绕过与流量加密",
		"拒绝服务 - 服务瘫痪与资源耗尽",
		"自动化攻击 - 一键式攻击流程",
	}

	for _, text := range features {
		displayText := "  • " + text
		padding := bannerWidth - getRealWidth(displayText)
		paddingStr := strings.Repeat(" ", padding)
		fmt.Println(red("║") + cyan(displayText) + paddingStr + red("║"))
	}

	// 底部边框
	fmt.Println(red("╚" + topBorder + "╝"))
	fmt.Println()
}
